package com.ruoyi.appService.wxuser.service.impl;

//import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
//import java.util.List;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.stereotype.Service;
//import com.ruoyi.system.mapper.ZWxuserMapper;
//import com.ruoyi.system.domain.ZWxuser;
//import com.ruoyi.system.service.IZWxuserService;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.appService.wxuser.domain.ZWxuser;
import com.ruoyi.appService.wxuser.domain.loginVO;
import com.ruoyi.appService.wxuser.mapper.ZWxuserMapper;
import com.ruoyi.appService.wxuser.service.IZWxuserService;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.framework.web.service.WxTokenService;
import com.ruoyi.framework.web.service.wxUserRedis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpServletRequest;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;

/**
 * 微信用户Service业务层处理
 *
 * @author ç¹è½æ²
 * @date 2025-03-31
 */
@Service
public class ZWxuserServiceImpl extends ServiceImpl<ZWxuserMapper, ZWxuser> implements IZWxuserService {
    @Autowired
    private ZWxuserMapper zWxuserMapper;
    @Autowired
    private WxTokenService wxTokenService;

    /**
     * 查询微信用户
     *
     * @param id 微信用户主键
     * @return 微信用户
     */
    @Override
    public ZWxuser selectZWxuserById(String id) {
        return zWxuserMapper.selectZWxuserById(id);
    }

    /**
     * 查询微信用户列表
     *
     * @param zWxuser 微信用户
     * @return 微信用户
     */
    @Override
    public List<ZWxuser> selectZWxuserList(ZWxuser zWxuser) {
        return zWxuserMapper.selectZWxuserList(zWxuser);
    }

    /**
     * 新增微信用户
     *
     * @param zWxuser 微信用户
     * @return 结果
     */
    @Override
    public int insertZWxuser(ZWxuser zWxuser) {
            return zWxuserMapper.insertZWxuser(zWxuser);
    }

    /**
     * 修改微信用户
     *
     * @param zWxuser 微信用户
     * @return 结果
     */
    @Override
    public int updateZWxuser(ZWxuser zWxuser) {
        return zWxuserMapper.updateZWxuser(zWxuser);
    }

    /**
     * 批量删除微信用户
     *
     * @param ids 需要删除的微信用户主键
     * @return 结果
     */
    @Override
    public int deleteZWxuserByIds(String[] ids) {
        return zWxuserMapper.deleteZWxuserByIds(ids);
    }

    /**
     * 删除微信用户信息
     *
     * @param id 微信用户主键
     * @return 结果
     */
    @Override
    public int deleteZWxuserById(String id) {
        return zWxuserMapper.deleteZWxuserById(id);
    }

    @Override
    public ZWxuser wxuserInfo(HttpServletRequest request) {

//从请求头中获取token
        String token = wxTokenService.getToken(request);
//解析得到token得到键，想redis中查找对应的值，并返回
        wxUserRedis wxuserRedis = wxTokenService.getwxUser(token);

//根据id查询微信用户详细信息
        QueryWrapper qw1 = new QueryWrapper<>();
        qw1.eq("id", wxuserRedis.getUserId());
        qw1.select("nickname","sex","avatar","telephone","studentID","name","birth","enterSchoolYear","DegreeGrade","DegreeType","schoolStatu");
        ZWxuser zWxuser1 = zWxuserMapper.selectOne(qw1);



        return zWxuser1;
    }


//    修改微信用户信息
    @Override
    public void updateWXuser(ZWxuser zwxuser, HttpServletRequest request) {

        //检测是否为空。。。。。

 //    //从请求头中获取token
        String token = wxTokenService.getToken(request);
//解析得到token得到键，想redis中查找对应的值，并返回
        wxUserRedis wxuserRedis = wxTokenService.getwxUser(token);
//    重新设置用户信息
        UpdateWrapper<ZWxuser> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", wxuserRedis.getUserId());
        zWxuserMapper.update(zwxuser, updateWrapper);

    }


//  修改手机号
    @Override
    public AjaxResult restTelephone(loginVO loginvo, HttpServletRequest request) {

        String telephone=loginvo.getTelephone();
        if (StringUtils.isEmpty(telephone) || StringUtils.isNull(telephone)) {
            return AjaxResult.error(401, "手机号不能为空");
        }

//          手机号唯一
        QueryWrapper qw1 = new QueryWrapper<>();
        qw1.eq("telephone",telephone);
        ZWxuser zWxuser1 = zWxuserMapper.selectOne(qw1);
        if (StringUtils.isNotNull(zWxuser1)) {
            return AjaxResult.error(401, "手机号已存在");
        }


        //从请求头中获取token
        String token = wxTokenService.getToken(request);
//解析得到token得到键，想redis中查找对应的值，并返回
        wxUserRedis wxuserRedis = wxTokenService.getwxUser(token);
//    重新设置手机号
        UpdateWrapper<ZWxuser> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", wxuserRedis.getUserId());
        ZWxuser zWxuser = new ZWxuser();
        zWxuser.setTelephone(telephone);
        zWxuserMapper.update(zWxuser, updateWrapper);
        return AjaxResult.error(200, "手机号修改成功");

    }

    @Override
    public AjaxResult restPassword(ZWxuser wxuser) {
        String password = wxuser.getPassword();
        String telephone = wxuser.getTelephone();

        //                    判断密码是否为空
        if (StringUtils.isEmpty(password) || StringUtils.isNull(password)) {
            return AjaxResult.error(401, "密码不能为空");
        }
        //                    判断手机号是否为空
        if (StringUtils.isEmpty(telephone) || StringUtils.isNull(telephone)) {
            return AjaxResult.error(401, "手机号不能为空");
        }


//   判断数据库中有没有这个手机号

        ZWxuser selectWxuser = new ZWxuser();
        selectWxuser.setTelephone(wxuser.getTelephone());
        List<ZWxuser> list = zWxuserMapper.selectZWxuserList(selectWxuser);
        if (list.size() != 0) {
//      数据库有有手机号，修改密码
            wxuser.setId(list.get(0).getId());
            wxuser.setPassword(password);
            zWxuserMapper.updateZWxuser(wxuser);
            return new AjaxResult(200, "密码修改成功");

        } else {
            return AjaxResult.error(401, "该手机号未注册");
        }




    }

    @Override
    public AjaxResult bindTelephone(ZWxuser wxuser, HttpServletRequest request) {

        String telephone = wxuser.getTelephone();
        String studentID = wxuser.getStudentID();
        if (StringUtils.isEmpty(telephone) || StringUtils.isNull(telephone)) {
            return AjaxResult.error(401, "手机号不能为空");
        }
        if (StringUtils.isEmpty(studentID) || StringUtils.isNull(studentID)) {
            return AjaxResult.error(401, "学号不能为空");
        }
        if (!telephone.matches("[1]\\d{10}")) {
            return AjaxResult.error(401, "手机号格式不对");
        }


//发送验证码逻辑


//          学号唯一
        QueryWrapper qw1 = new QueryWrapper<>();
        qw1.eq("studentID", studentID);
        ZWxuser zWxuser1 = zWxuserMapper.selectOne(qw1);
        if (StringUtils.isNotNull(zWxuser1)) {
            return AjaxResult.error(401, "学号已存在");
        }


//从请求头中获取token
        String token = wxTokenService.getToken(request);
//解析得到token得到键，想redis中查找对应的值，并返回
        wxUserRedis wxuserRedis = wxTokenService.getwxUser(token);

//修改学号，即添加学号。先根据id查找到记录
        UpdateWrapper<ZWxuser> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", wxuserRedis.getUserId());
        ZWxuser zWxuser = new ZWxuser();
        zWxuser.setStudentID(wxuser.getStudentID());
        zWxuserMapper.update(zWxuser, updateWrapper);
        return new AjaxResult(200, "绑定成功");

    }

    @Override
    public AjaxResult register(ZWxuser wxuser) {


//    先判断账号、密码、手机号是否为空
        String studentID = wxuser.getStudentID();
        String telephone = wxuser.getTelephone();
        String password = wxuser.getPassword();

//                    判断学号是否为空
        if (StringUtils.isEmpty(studentID) || StringUtils.isNull(studentID)) {
            return AjaxResult.error(401, "学号不能为空");
        }
//                    判断手机号是否为空
        if (StringUtils.isEmpty(telephone) || StringUtils.isNull(telephone)) {
            return AjaxResult.error(401, "手机号不能为空");
        }
//                    判断密码是否为空
        if (StringUtils.isEmpty(password) || StringUtils.isNull(password)) {
            return AjaxResult.error(401, "密码不能为空");
        }


//    要求手机号唯一         学号唯一

        QueryWrapper qw1 = new QueryWrapper<>();
        qw1.eq("studentID", studentID);
        ZWxuser zWxuser1 = zWxuserMapper.selectOne(qw1);
        if (StringUtils.isNotNull(zWxuser1)) {
            return AjaxResult.error(401, "学号已存在");
        }

        QueryWrapper qw2 = new QueryWrapper<>();
        qw2.eq("telephone", telephone);
        ZWxuser zWxuser2 = zWxuserMapper.selectOne(qw2);
        if (StringUtils.isNotNull(zWxuser2)) {
            return AjaxResult.error(401, "手机号已存在");
        }

        //    随机生成昵称
        String nickTime = String.valueOf(System.currentTimeMillis());
        wxuser.setNickname("用户" + nickTime);


        zWxuserMapper.insert(wxuser);
        return new AjaxResult(200, "注册成功");


    }

    @Override
    public AjaxResult login(loginVO loginvo) {

        if (StringUtils.isNotNull(loginvo.getCode()) && StringUtils.isNotEmpty(loginvo.getCode())) {
            //按微信登录逻辑

//        这里设置一个map集合，模拟接收到code码后，想微信接口提供code码得到openid
            HashMap<String, String> map = new HashMap<>();
//        已注册，绑定学号的
            map.put("abcdefg", "123456");
            map.put("sssdsdd", "123244");
//        已注册，未绑定学号的
            map.put("ssdwew", "4588554");
//        未注册的
            map.put("a123456", "a123456");//微信绑定的手机号已存于数据库中，绑定失败
            map.put("b123456", "b123456");
            map.put("c123456", "c123456");
            map.put("d123456", "d123456");


//        模拟微信授权，获得手机号
            HashMap<String, String> telephoneMap = new HashMap<>();
            telephoneMap.put("a123456", "13373272855");
            telephoneMap.put("b123456", "13373272856");
            telephoneMap.put("c123456", "13373272857");
            telephoneMap.put("d123456", "13373272858");


//            模拟根据code查找出对应的openid
            String openid = map.get(loginvo.getCode());
//            判断openid是否为空
            if (StringUtils.isEmpty(openid)) {
                return AjaxResult.error(401, "微信登录失败，无效code码");
            }

//              根据openid  在数据库中查找有没有这个用户
            ZWxuser wxuser = new ZWxuser();
            wxuser.setOpenid(openid);
            List<ZWxuser> list = zWxuserMapper.selectZWxuserList(wxuser);


            if (list.size() != 0) {
//                   生成jwt令牌
                wxUserRedis wxuserredis = new wxUserRedis();
                wxuserredis.setUserId(list.get(0).getId());
                String token = wxTokenService.createToken(wxuserredis);
//                  判断是否有手机号  0表示持有  1表示未持有
                String StudentID = list.get(0).getStudentID();
                String haveStudentID = (StringUtils.isNotNull(StudentID) && StringUtils.isNotEmpty(StudentID)) ? "0" : "1";
//                  存储要返回的数据
                Hashtable<String, Object> Resultmap = new Hashtable<>();
                Resultmap.put("token", token);
                Resultmap.put("haveStudentID", haveStudentID);

//                  data: token:xxxxxx,xxxxxx,xxxxxx
                return new AjaxResult(200, "操作成功", Resultmap);


            } else {
//              System.out.println("该用户没有注册过，自动注册");

                //模拟微信授权获得手机号
                String telephone = telephoneMap.get(openid);
                //如果学号登录时绑定过这个手机号，则无法实现微信登录
                QueryWrapper qw1 = new QueryWrapper<>();
                qw1.eq("telephone", telephone);
                ZWxuser zWxuser1 = zWxuserMapper.selectOne(qw1);
                if (StringUtils.isNotNull(zWxuser1)) {
                    return AjaxResult.error(401, "注册失败，微信绑定的手机号已占用");
                }
                wxuser.setTelephone(telephone);


                //    随机生成昵称
                String nickTime = String.valueOf(System.currentTimeMillis());
                wxuser.setNickname("用户" + nickTime);
                //存入openid
                wxuser.setOpenid(openid);
                //数据库中添加用户
                zWxuserMapper.insert(wxuser);


                //           生成jwt令牌
                QueryWrapper qw2 = new QueryWrapper<>();
                qw2.eq("telephone", telephone);
                ZWxuser zWxuser2 = zWxuserMapper.selectOne(qw2);

                wxUserRedis wxuserredis = new wxUserRedis();
                wxuserredis.setUserId(zWxuser2.getId());
                String token = wxTokenService.createToken(wxuserredis);
//            学号为1 表示该微信用户并没有绑定学号
                String haveStudentID = "1";
//                  存储要返回的数据
                Hashtable<String, Object> Resultmap = new Hashtable<>();
                Resultmap.put("token", token);
                Resultmap.put("haveStudentID", haveStudentID);

//                  data: token:xxxxxx,xxxxxx,xxxxxx
                return new AjaxResult(200, "操作成功", Resultmap);

            }


        } else {
            //            按学号登录的逻辑
            String studentID = loginvo.getStudentID();
            String password = loginvo.getPassword();

//                判断学号是否为空
            if (StringUtils.isEmpty(studentID) || StringUtils.isNull(studentID)) {
                return AjaxResult.error(401, "学号不能为空");
            }
//                判断密码是否为空
            if (StringUtils.isEmpty(password) || StringUtils.isNull(password)) {
                return AjaxResult.error(401, "密码不能为空");
            }
//                查询数据
            ZWxuser testRepeatWxuser = new ZWxuser();
            testRepeatWxuser.setPassword(loginvo.getPassword());
            testRepeatWxuser.setStudentID(loginvo.getStudentID());
            List<ZWxuser> list = zWxuserMapper.selectZWxuserList(testRepeatWxuser);
//                判断能否查到数据
            if (list.size() == 0) {
                return AjaxResult.error(401, "账号或密码错误");
            }
//                   生成jwt令牌，并把token和用户信息返回去
            wxUserRedis wxuserredis = new wxUserRedis();
            wxuserredis.setUserId(list.get(0).getId());
            String token = wxTokenService.createToken(wxuserredis);
            Hashtable<String, Object> Resultmap = new Hashtable<>();

            Resultmap.put("token", token);
            return new AjaxResult(200, "操作成功", Resultmap);


        }







    }
}